Node 中的协程

Node.js 是单线程么？是，也不是~

Node.js 使用事件驱动及非阻塞 I/O 实现异步模型

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

APPLICATION 为我们所编写的应用层，其 JS 的解释执行由 V8 引擎负责，这里的执行线程只有一个，这也就是通常所说 Node.js 为单线程的原因，在编写 Node.js 程序时没有办法创建子线程，同时如果有部分逻辑阻塞或者长时间运行，则会影响整个运行时

Node.js 的高并发则依赖事件驱动（EVENT LOOP）及非阻塞 I/O（LIBUV），在进行 I/O 操作时 Node.js 将任务交由UV线程池中的线程执行，并在事件队列中注册回调，在 I/O 操作完成时触发回调继续后续的动作，在整个 I/O 操作的过程中并不会阻塞 JS 的解释执行

• Node.js 的 JavaScript 解释执行只有一个线程，阻塞或长时运行的逻辑会影响整个应用层的运行
• I/O 操作交由UV线程池处理（通过 addones 也可以将 CPU 密集型的计算逻辑放到 LIBUV 线程池中执行），通过事件机制回调将结果返回给应用层处理

Node.js 的工作线程数固定（可通过环境变量 UV_THREADPOOL_SIZE 指定），每个工作线程对应一个内核线程，工作线程数可以理解为 N:M 线程模型中的 M

Node.js 应用层的异步任务由开发人员编写，每个异步任务可以理解为用户线程，任务数对应于 N:M 线程模型中的 N

由于 Node.js 上述的特点（单执行线程，多工作线程），没有过多的干扰，非常适合用来讲述协程的概念及应用

Geneartor

子程序（或者称为函数），在所有语言中都是层级调用，严格遵循线程栈的入栈出栈，子程序调用总是一个入口一个返回，调用顺序是明确的

而协程的调用和子程序不同，协程看上去也是子程序，但执行过程中协程内部可中断，然后转而执行别的子程序/协程，在适当的时候再返回来接着执行

generator 函数是 ES6 提供的一种异步编程解决方案，语法行为与传统函数完全不同

function* helloGenerator() {
  yield console.log("hello")
  yield console.log("I'm")
}

function* worldGenerator() {
  yield console.log("world")
  yield console.log("ManerFan")
}

let hello = helloGenerator()
let world = worldGenerator()

// 交替执行helloGenerator及worldGenerator
hello.next()
world.next()
hello.next()
world.next()

运行结果

hello
world
I'm
ManerFan

按照常理，在同一个线程中顺序调用 helloGenerator 及 worldGenerator ，两个函数均会按照调用顺序完整的执行，按预期应该输出

hello
I'm
world
ManerFan

在使用 generator 时，其 next 方法会在方法体内遇到 yield 关键字时暂停执行，交回该函数的执行权，类似于线程的挂起，因此 generator 也被称之为暂停函数

generator 函数可以在内部使用 yield 关键字标识暂停点，generator 函数的暂停、恢复执行可由应用程序灵活控制（内核线程的调度由系统控制），这与传统函数的执行规则完全不同，generator 函数的调度权完全交给了应用层

yield 关键字除了标识暂停点之外，还可以在恢复执行的时候传值进来

function* foo(x) {
  var y = 2 * (yield x + 1)
  var z = yield y / 3
  return x + y + z
}

let f = foo(5)
let step1 = f.next()
console.log(step1) // { value:6, done:false }
let step2 = f.next(12)
console.log(step2) // { value:8, done:false }
let step3 = f.next(13)
console.log(step3) // { value:42, done:true }

不论事件还是 Promise 亦或响应式都离不开回调，事件将主流程与异步回调分离，Promise 将异步回调转为链式回调，响应式将异步回调转为流式回调，当 generator 遇到异步回调会发生什么？

以下，模拟定义 $.get 函数如下

let $ = {
  get(url, callback) {
    setTimeout(() => callback(url.substring(5)), 500)
  },
}

以回调嵌套为例

// 回调方式
$.get("step/1", (data1) => {
  $.get(`step/2/${data1}`, (data2) => {
    $.get(`step/3/${data2}`, (data3) => {
      /* do the final thing */
    })
  })
})

利用 generator 可暂停、可恢复的能力，可在异步回调逻辑中触发恢复下一步的动作，并将当前的异步处理结果带回，以此将回调嵌套拉平，将异步回调逻辑写出同步的顺滑感，我们称之为异步逻辑的“同步化”（同步的写法，异步的执行）

// 封装异步调用
function get(url) {
  $.get(url, (data) => {
    // 触发后续流程，并将数据代入后续流程
    req.next(data)
  })
}

// generator 异步逻辑同步化
function* asyncAsSync() {
  // 同步的写法，异步的执行
  let result1 = yield get("step/1")
  let result2 = yield get(`step/2/${result1}`)
  let result3 = yield get(`step/3/${result2}`)
  console.log(result3)
  /* do the final thing */
}

// 生成generator
var req = asyncAsSync()
// 触发一次
req.next()

// do something at the same time
console.log("do something at the same time when excute gets")

输出

do something at the same time when excute gets
3/2/1

asyncAsSync 函数中看似是同步的逻辑，实则每一个 yield get()都是一次异步调用，异步的结果通过 req.next()带回，并且 asyncAsSync 函数的调用并不会阻塞最后一行 console.log 的执行

在此之上还有一种方法可以自动的执行 generator 的 next 函数，那就是科里化，这里就不再赘述

generator 的实际应用（koa）

将 generator 的精髓用到极致的还要当属 koa（koa2 已经使用 async 改写，不再使用 generator），它将 http server 端异步 middleware 的书写体验整个提升了一个层级

middleware 类似于 java servlet 中的 filter，其执行过程类似于剥洋葱

而当所有的 middleware（包括核心 core）都是异步的话，整个处理逻辑在各 middleware 之间的跳转就变得复杂起来

koa 使用 generator 的特性，巧妙实现了请求处理逻辑在各异步 middleware 间的灵活跳转执行

以下，简单模拟 koa-middleware 的实现逻辑

// 定义app
let app = {
  middlewares: [],

  core: function* (next) {
    console.log("excute core!")
    // yield 异步操作
    yield* next
  },

  // 将多个middleware组合成链式结构
  compose(middlewares) {
    function* noop() {}
    return function* (next) {
      var i = middlewares.length
      var prev = next || noop()
      var curr

      while (i--) {
        curr = middlewares[i]
        prev = curr.call(this, prev)
      }

      yield* prev
    }
  },

  // 添加middleware
  use(middleware) {
    this.middlewares.push(middleware)
  },

  run() {
    let chain = this.compose([...this.middlewares, this.core])
    co(chain)
  },
}

使用

app.use(function* (next) {
  console.log("before middleware1")
  // yield 异步操作
  yield* next
  console.log("after middleware1")
  // yield 异步操作
})

app.use(function* (next) {
  console.log("before middleware2")
  // yield 异步操作
  yield* next
  console.log("after middleware2")
  // yield 异步操作
})

app.run()

输出

before middleware1
before middleware2
excute core!
after middleware2
after middleware1

简单来讲，async 其实就是 generator 的语法糖

使用 async 替代 generator 的标星函数 function* 使用 await 替代 yield await 后可跟普通值、普通函数及 Promise 对象 async 自带自动执行器 async/await 相比 generator + thunk/Promise + co 的方案，更加语义化，也更容易理解

Node 支持协程吗?

Node 真的只是通过回调实现 async 吗

这里引用知乎一篇高赞答案:

如果你使用支持 ES6 的平台，Node.js 8+，那么就可以原生支持 coroutine。

考虑这段代码

async function foo() {
  await bar()
  return 42
}

async function bar() {
  await Promise.resolve()
  throw new Error("BEEP BEEP")
}

foo.catch((error) => console.log(error.stack))

在 Node 8 和 10 中运行此代码会产生以下输出

虽然调用 foo() 导致错误，但 foo 根本不是堆栈跟踪的一部分。

但是在 ES7 中，这可是真·协程啊，因此引擎知道 bar 调用完成时它继续执行的位置：在 foo 函数的 await 之后。巧合的是，这也是函数 foo 暂停的地方。引擎可以使用此信息来重建异步堆栈跟踪的部分，即 await 线程。通过此更改，输出变为

在补充一点，看看在 V8 引擎中是如何实现的。

JSGeneratorObject 定义在 objects/js-generator.h 中：

看看这几个方法名，你还怀疑 node.js 是假协程吗？

创建协程定义在 runtime/runtime-generator.cc

先检查函数类型，是否可以被暂停，resumable。创建 JSGeneratorObject 对象，保护现场，运行。